

package main.new_2024.month_12;


import java.util.*;

/**
 * @Description: todo 394. 字符串解码
 * 给你一个下标从 0 开始的 正 整数数组 nums 。
 * 如果 nums 的一个子数组满足：移除这个子数组后剩余元素 严格递增 ，
 * 那么我们称这个子数组为 移除递增 子数组。比方说，[5, 3, 4, 6, 7] 中的 [3, 4] 是一个移除递增子数组，因为移除该子数组后，[5, 3, 4, 6, 7] 变为 [5, 6, 7] ，是严格递增的。
 * 请你返回 nums 中 移除递增 子数组的总数目。
 * 注意 ，剩余元素为空的数组也视为是递增的。
 * 子数组 指的是一个数组中一段连续的元素序列。
 *
 * todo 933. 最近的请求次数
 * 写一个 RecentCounter 类来计算特定时间范围内最近的请求。
 * 请你实现 RecentCounter 类：
 * RecentCounter() 初始化计数器，请求数为 0 。
 * int ping(int t) 在时间 t 添加一个新请求，其中 t 表示以毫秒为单位的某个时间，并返回过去 3000 毫秒内发生的所有请求数（包括新请求）。确切地说，返回在 [t-3000, t] 内发生的请求数。
 * 保证 每次对 ping 的调用都使用比之前更大的 t 值。
 *
 * todo 875. 爱吃香蕉的珂珂
 * 珂珂喜欢吃香蕉。这里有 n 堆香蕉，第 i 堆中有 piles[i] 根香蕉。警卫已经离开了，将在 h 小时后回来。
 * 珂珂可以决定她吃香蕉的速度 k （单位：根/小时）。每个小时，她将会选择一堆香蕉，从中吃掉 k 根。如果这堆香蕉少于 k 根，她将吃掉这堆的所有香蕉，然后这一小时内不会再吃更多的香蕉。
 * 珂珂喜欢慢慢吃，但仍然想在警卫回来前吃掉所有的香蕉。
 * 返回她可以在 h 小时内吃掉所有香蕉的最小速度 k（k 为整数）。
 *
 *
 * @Author: Take-off
 * @Date: 1:00 PM 2024/2/27
 * @Param:
 * @return:
 **/
public class Solution1217 {

    public int minEatingSpeed(int[] piles, int h) {
        int left = 0;
        int right = left;
        for (int pile:piles){
            right = Math.max(right, pile);
        }
        while (left + 1 < right){
            int mid = left + (right - left) /2;
            if (check(piles,h,mid)){
                right = mid;
            }else {
                left = mid;
            }
        }
        return right;
    }

    //检查可能性
    private boolean check(int[] piles, int h,int mid){
        int sum = 0;
        for (int pile:piles){
            sum += pile / mid;
            if (pile % mid != 0) sum++;
            if (sum > h){
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        Solution1217 test = new Solution1217();
        System.out.println();
    }


    private Queue<Integer> tempList = new LinkedList<>();

    private static Integer range = 3000;

    public Solution1217() {
        tempList = new LinkedList<Integer>();
    }

    public int ping(int t) {
        tempList.offer(t);
        int left = t - range;
        while (tempList.peek() < left ){
            tempList.poll();
        }
        return tempList.size();
    }

    public String decodeString(String s) {
        StringBuilder ref = new StringBuilder("");
        Stack<Integer> interStack = new Stack<>();
        Stack<StringBuilder> strStack = new Stack<>();
        Integer intTemp = 0;
        for (char temp:s.toCharArray()){
            if (temp >= '0' && temp <= '9'){
                //数字
                intTemp =   temp - '0' + intTemp * 10;
            }else if (temp == '[' ){
                //入栈
                interStack.add(intTemp);
                intTemp = 0;
                strStack.add(ref);
                ref = new StringBuilder();
            }else if (temp == ']' ){
                //出栈
                Integer intPop = interStack.pop();
                StringBuilder tempSb = new StringBuilder();
                for (int i =0;i<intPop;i++){
                    tempSb.append(ref);
                }
                ref =strStack.pop().append(tempSb);
            }else {
                ref.append(temp);
            }
        }
        return ref.toString();
    }

}

